#include <bits/stdc++.h>
using namespace std;

/*

*/


/**
 * Your FindSumPairs object will be instantiated and called as such:
 * FindSumPairs* obj = new FindSumPairs(nums1, nums2);
 * obj->add(index,val);
 * int param_2 = obj->count(tot);
 */

// 法一
class FindSumPairs {
public:
    FindSumPairs(vector<int>& nums1, vector<int>& nums2) {
        this->nums1 = nums1;
        this->nums2 = nums2;
        for (int num : nums1)   freq1[num]++;
        for (int num : nums2)   freq2[num]++;
    }
    
    void add(int index, int val) {
        // 旧值 更新频率
        int old_val = nums2[index];
        freq2[old_val]--;
        if (freq2[old_val] == 0)    freq2.erase(old_val);

        // 更新num2的val
        nums2[index] += val;
        // 新值 更新频率
        int new_val = nums2[index];
        freq2[new_val]++;
    }
    
    int count(int tot) {
        int ans = 0;
        // 遍历nums1中的数字，查找nums2中对应的补数
        for (auto& [num, cnt] : freq1) {
            int comp = tot - num;
            if (freq2.count(comp))  ans += cnt * freq2[comp];
        }
        return ans;
    }

private:
    vector<int> nums1;
    vector<int> nums2;
    unordered_map<int, int> freq1;  // nums1中数字的频率统计
    unordered_map<int, int> freq2;  // nums2中数字的频率统计
};

// 法二
/**
 * @class FindSumPairs
 * @brief 支持两类查询的数据结构：累加操作和计数操作
 *
 * 该类用于高效处理两类操作：
 * 1. 将值加到nums2指定元素上
 * 2. 统计满足nums1[i] + nums2[j]等于指定值的下标对数目
 *
 * 设计思路：
 * - 使用哈希表记录nums2中元素的频率，以实现O(1)时间复杂度的查询和更新
 * - 遍历nums1进行计数查询，避免直接双重循环带来的性能问题
 */
class FindSumPairs {
    static const int MAX_NUM = 1e9; // 定义最大数值常量，防止溢出

public:
    /**
     * @brief 构造函数，初始化数据结构
     * @param nums1 第一个整数数组（不会被修改）
     * @param nums2 第二个整数数组（会被修改）
     *
     * 初始化步骤：
     * 1. 保存nums1和nums2的引用
     * 2. 统计nums2中每个元素的出现频率
     */
    FindSumPairs(vector<int>& nums1, vector<int>& nums2)
        : n1(nums1), n2(nums2) {
        for (auto n : nums2) {
            ++counts[n]; // 初始化频率统计哈希表
        }
    }

    /**
     * @brief 将值加到nums2的指定下标元素上
     * @param index nums2的索引
     * @param val 要加的值
     *
     * 操作步骤：
     * 1. 检查当前值是否已达到最大值（防止溢出）
     * 2. 更新频率统计：先减少旧值的计数
     * 3. 修改nums2中的值
     * 4. 增加新值的计数（如果新值小于最大值）
     */
    void add(int index, int val) {
        if (n2[index] >= MAX_NUM) {
            return; // 防止数值溢出
        }
        --counts[n2[index]]; // 减少旧值的计数
        n2[index] += val;    // 更新数组中的值
        if (n2[index] < MAX_NUM) {
            ++counts[n2[index]]; // 增加新值的计数)
        }
    }

    /**
     * @brief 统计满足nums1[i] + nums2[j] == tot的下标对数目
     * @param tot 目标和值
     * @return 满足条件的下标对数目
     *
     * 算法逻辑：
     * 1. 遍历nums1中的每个元素n
     * 2. 对于每个n，计算补数tot - n
     * 3. 在频率哈希表中查找补数的出现次数
     * 4. 累加所有有效的配对数目
     */
    int count(int tot) {
        int r = 0;
        for (auto n : n1) {
            if (n >= tot)
                continue; // 跳过不可能产生有效配对的元素
            auto it = counts.find(tot - n);
            if (it != counts.end()) {
                r += it->second; // 累加匹配的数目
            }
        }
        return r;
    }

private:
    vector<int>& n1;                // nums1的引用（只读）
    vector<int>& n2;                // nums2的引用（会被修改）
    unordered_map<int, int> counts; // nums2中元素的频率统计
};


// 法三
class FindSumPairs {
    unordered_map<int, int> cnt;   // 存储nums1中数字的频率统计（初始化后不变）
    unordered_map<int, int> cnt2;  // 存储nums2中数字的动态频率统计（随add操作更新）
    vector<int> nums2;             // 存储nums2的原始数组（支持按索引修改）

public:
    /**
     * 初始化数据结构：
     * 1. 对nums1做频率统计（后续不修改）
     * 2. 接管nums2数据所有权（避免拷贝）
     * 3. 初始化nums2的频率统计
     */
    FindSumPairs(vector<int>& nums1, vector<int>& _nums2) 
        : cnt{}
        , nums2{std::move(_nums2)}  // 移动语义转移数据
    {
        for (int v : nums1) ++cnt[v];    // O(N)统计nums1频率
        for (int v : nums2) ++cnt2[v];   // O(M)统计nums2初始频率
    }
    
    /**
     * 修改nums2[index]的值：
     * 1. 减少旧值的频率计数（若计数归零则移除键）
     * 2. 更新nums2数组中的值
     * 3. 增加新值的频率计数
     * 时间复杂度：O(1)哈希表操作
     */
    void add(int index, int val) {
        int& x = nums2[index];          // 获取目标元素的引用
        if (!--cnt2[x]) cnt2.erase(x);  // 更新旧值的频率（自动清理零计数）
        ++cnt2[x += val];               // 更新新值的频率
    }
    
    /**
     * 统计满足 nums1[i] + nums2[j] = tot 的下标对数量：
     * 1. 遍历nums1的频率表，对每个数字v，查找补数(tot - v)在nums2中的出现次数
     * 2. 累加所有有效组合的数量（频率乘积）
     * 时间复杂度：O(U)，U为nums1中不同数字的数量
     */
    int count(int tot) {
        int res = 0;
        for (auto [v, c] : cnt) {                   // 遍历nums1的数字频率
            if (v <= tot && cnt2.contains(tot - v))  // 过滤无效查询（v > tot时无解）
                res += c * cnt2[tot - v];           // 累加组合数
        }
        return res;
    }
};